Move all GdkDevice members to private and add one missing accessor

diff --git a/gdk/gdkdevice.c b/gdk/gdkdevice.c
index 593e265af29359ef448f971e4d69cc1c13377536..c84c332292998fd0346d8c33d0717f05d3317ac9 100644 (file)
--- a/gdk/gdkdevice.c
+++ b/gdk/gdkdevice.c
@@ -43,6 +43,12 @@ struct _GdkAxisInfo
 
 struct _GdkDevicePrivate
 {
+  gchar *name;
+  GdkInputSource source;
+  GdkInputMode mode;
+  gboolean has_cursor;
+  gint num_keys;
+  GdkDeviceKey *keys;
   GdkDeviceManager *device_manager;
   GdkDisplay *display;
   GdkDevice *associated;
@@ -261,13 +267,11 @@ gdk_device_dispose (GObject *object)
       priv->axes = NULL;
     }
 
-  g_free (device->name);
-  g_free (device->keys);
-  g_free (device->axes);
+  g_free (priv->name);
+  g_free (priv->keys);
 
-  device->name = NULL;
-  device->keys = NULL;
-  device->axes = NULL;
+  priv->name = NULL;
+  priv->keys = NULL;
 
   G_OBJECT_CLASS (gdk_device_parent_class)->dispose (object);
 }
@@ -290,22 +294,22 @@ gdk_device_set_property (GObject      *object,
       priv->device_manager = g_value_get_object (value);
       break;
     case PROP_NAME:
-      if (device->name)
-        g_free (device->name);
+      if (priv->name)
+        g_free (priv->name);
 
-      device->name = g_value_dup_string (value);
+      priv->name = g_value_dup_string (value);
       break;
     case PROP_TYPE:
       priv->type = g_value_get_enum (value);
       break;
     case PROP_INPUT_SOURCE:
-      device->source = g_value_get_enum (value);
+      priv->source = g_value_get_enum (value);
       break;
     case PROP_INPUT_MODE:
       gdk_device_set_mode (device, g_value_get_enum (value));
       break;
     case PROP_HAS_CURSOR:
-      device->has_cursor = g_value_get_boolean (value);
+      priv->has_cursor = g_value_get_boolean (value);
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -334,21 +338,19 @@ gdk_device_get_property (GObject    *object,
       g_value_set_object (value, priv->associated);
       break;
     case PROP_NAME:
-      g_value_set_string (value,
-                          device->name);
+      g_value_set_string (value, priv->name);
       break;
     case PROP_TYPE:
       g_value_set_enum (value, priv->type);
       break;
     case PROP_INPUT_SOURCE:
-      g_value_set_enum (value, device->source);
+      g_value_set_enum (value, priv->source);
       break;
     case PROP_INPUT_MODE:
-      g_value_set_enum (value, device->mode);
+      g_value_set_enum (value, priv->mode);
       break;
     case PROP_HAS_CURSOR:
-      g_value_set_boolean (value,
-                           device->has_cursor);
+      g_value_set_boolean (value, priv->has_cursor);
       break;
     case PROP_N_AXES:
       g_value_set_uint (value, priv->axes->len);
@@ -438,7 +440,7 @@ _gdk_device_allocate_history (GdkDevice *device,
 
   for (i = 0; i < n_events; i++)
     result[i] = g_malloc (sizeof (GdkTimeCoord) -
-                         sizeof (double) * (GDK_MAX_TIMECOORD_AXES - device->num_axes));
+                         sizeof (double) * (GDK_MAX_TIMECOORD_AXES - device->priv->axes->len));
   return result;
 }
 
@@ -476,7 +478,7 @@ gdk_device_get_name (GdkDevice *device)
 {
   g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
 
-  return device->name;
+  return device->priv->name;
 }
 
 /**
@@ -494,7 +496,7 @@ gdk_device_get_has_cursor (GdkDevice *device)
 {
   g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);
 
-  return device->has_cursor;
+  return device->priv->has_cursor;
 }
 
 /**
@@ -512,7 +514,7 @@ gdk_device_get_source (GdkDevice *device)
 {
   g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
 
-  return device->source;
+  return device->priv->source;
 }
 
 /**
@@ -528,7 +530,8 @@ gdk_device_set_source (GdkDevice      *device,
 {
   g_return_if_fail (GDK_IS_DEVICE (device));
 
-  device->source = source;
+  device->priv->source = source;
+  g_object_notify (G_OBJECT (device), "input-source");
 }
 
 /**
@@ -546,7 +549,7 @@ gdk_device_get_mode (GdkDevice *device)
 {
   g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
 
-  return device->mode;
+  return device->priv->mode;
 }
 
 /**
@@ -566,7 +569,7 @@ gdk_device_set_mode (GdkDevice    *device,
 {
   g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);
 
-  if (device->mode == mode)
+  if (device->priv->mode == mode)
     return TRUE;
 
   if (mode == GDK_MODE_DISABLED &&
@@ -575,7 +578,7 @@ gdk_device_set_mode (GdkDevice    *device,
 
   /* FIXME: setting has_cursor when mode is window? */
 
-  device->mode = mode;
+  device->priv->mode = mode;
   g_object_notify (G_OBJECT (device), "input-mode");
 
   if (gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_MASTER)
@@ -584,6 +587,24 @@ gdk_device_set_mode (GdkDevice    *device,
   return TRUE;
 }
 
+/**
+ * gdk_device_get_n_keys:
+ * @device: a #GdkDevice
+ *
+ * Returns the number of keys the device currently has.
+ *
+ * Returns: the number of keys.
+ *
+ * Since: 3.0
+ **/
+gint
+gdk_device_get_n_keys (GdkDevice *device)
+{
+  g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
+
+  return device->priv->num_keys;
+}
+
 /**
  * gdk_device_get_key:
  * @device: a #GdkDevice.
@@ -605,17 +626,17 @@ gdk_device_get_key (GdkDevice       *device,
                     GdkModifierType *modifiers)
 {
   g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);
-  g_return_val_if_fail (index_ < device->num_keys, FALSE);
+  g_return_val_if_fail (index_ < device->priv->num_keys, FALSE);
 
-  if (!device->keys[index_].keyval &&
-      !device->keys[index_].modifiers)
+  if (!device->priv->keys[index_].keyval &&
+      !device->priv->keys[index_].modifiers)
     return FALSE;
 
   if (keyval)
-    *keyval = device->keys[index_].keyval;
+    *keyval = device->priv->keys[index_].keyval;
 
   if (modifiers)
-    *modifiers = device->keys[index_].modifiers;
+    *modifiers = device->priv->keys[index_].modifiers;
 
   return TRUE;
 }
@@ -637,10 +658,10 @@ gdk_device_set_key (GdkDevice      *device,
                    GdkModifierType modifiers)
 {
   g_return_if_fail (GDK_IS_DEVICE (device));
-  g_return_if_fail (index_ < device->num_keys);
+  g_return_if_fail (index_ < device->priv->num_keys);
 
-  device->keys[index_].keyval = keyval;
-  device->keys[index_].modifiers = modifiers;
+  device->priv->keys[index_].keyval = keyval;
+  device->priv->keys[index_].modifiers = modifiers;
 }
 
 /**
@@ -658,10 +679,14 @@ GdkAxisUse
 gdk_device_get_axis_use (GdkDevice *device,
                          guint      index_)
 {
+  GdkAxisInfo *info;
+
   g_return_val_if_fail (GDK_IS_DEVICE (device), GDK_AXIS_IGNORE);
-  g_return_val_if_fail (index_ < device->num_axes, GDK_AXIS_IGNORE);
+  g_return_val_if_fail (index_ < device->priv->axes->len, GDK_AXIS_IGNORE);
+
+  info = &g_array_index (device->priv->axes, GdkAxisInfo, index_);
 
-  return device->axes[index_].use;
+  return info->use;
 }
 
 /**
@@ -681,29 +706,27 @@ gdk_device_set_axis_use (GdkDevice   *device,
   GdkAxisInfo *info;
 
   g_return_if_fail (GDK_IS_DEVICE (device));
-  g_return_if_fail (index_ < device->num_axes);
+  g_return_if_fail (index_ < device->priv->axes->len);
 
   priv = device->priv;
   info = &g_array_index (priv->axes, GdkAxisInfo, index_);
   info->use = use;
 
-  device->axes[index_].use = use;
-
   switch (use)
     {
     case GDK_AXIS_X:
     case GDK_AXIS_Y:
-      device->axes[index_].min = info->min_axis = 0;
-      device->axes[index_].max = info->max_axis = 0;
+      info->min_axis = 0;
+      info->max_axis = 0;
       break;
     case GDK_AXIS_XTILT:
     case GDK_AXIS_YTILT:
-      device->axes[index_].min = info->min_axis = -1;
-      device->axes[index_].max = info->max_axis = 1;
+      info->min_axis = -1;
+      info->max_axis = 1;
       break;
     default:
-      device->axes[index_].min = info->min_axis = 0;
-      device->axes[index_].max = info->max_axis = 1;
+      info->min_axis = 0;
+      info->max_axis = 1;
       break;
     }
 }
@@ -817,12 +840,12 @@ gdk_device_get_device_type (GdkDevice *device)
  *
  * Since: 3.0
  **/
-guint
+gint
 gdk_device_get_n_axes (GdkDevice *device)
 {
   g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
 
-  return device->num_axes;
+  return device->priv->axes->len;
 }
 
 /**
@@ -1093,10 +1116,6 @@ _gdk_device_reset_axes (GdkDevice *device)
     g_array_remove_index (priv->axes, i);
 
   g_object_notify (G_OBJECT (device), "n-axes");
-
-  /* This is done for backwards compatibility */
-  g_free (device->axes);
-  device->axes = NULL;
 }
 
 guint
@@ -1138,16 +1157,7 @@ _gdk_device_add_axis (GdkDevice   *device,
     }
 
   priv->axes = g_array_append_val (priv->axes, axis_info);
-  device->num_axes = priv->axes->len;
-  pos = device->num_axes - 1;
-
-  /* This is done for backwards compatibility, since the public
-   * struct doesn't actually store the device data.
-   */
-  device->axes = g_realloc (device->axes, sizeof (GdkDeviceAxis) * priv->axes->len);
-  device->axes[pos].use = axis_info.use;
-  device->axes[pos].min = axis_info.min_axis;
-  device->axes[pos].max = axis_info.max_axis;
+  pos = device->priv->axes->len - 1;
 
   g_object_notify (G_OBJECT (device), "n-axes");
 
@@ -1158,11 +1168,11 @@ void
 _gdk_device_set_keys (GdkDevice *device,
                       guint      num_keys)
 {
-  if (device->keys)
-    g_free (device->keys);
+  if (device->priv->keys)
+    g_free (device->priv->keys);
 
-  device->num_keys = num_keys;
-  device->keys = g_new0 (GdkDeviceKey, num_keys);
+  device->priv->num_keys = num_keys;
+  device->priv->keys = g_new0 (GdkDeviceKey, num_keys);
 }
 
 static GdkAxisInfo *
@@ -1321,16 +1331,14 @@ _gdk_device_translate_screen_coord (GdkDevice *device,
                                     gdouble    value,
                                     gdouble   *axis_value)
 {
-  GdkDevicePrivate *priv;
+  GdkDevicePrivate *priv = device->priv;
   GdkAxisInfo axis_info;
   gdouble axis_width, scale, offset;
   GdkWindowObject *window_private;
 
-  if (device->mode != GDK_MODE_SCREEN)
+  if (priv->mode != GDK_MODE_SCREEN)
     return FALSE;
 
-  priv = device->priv;
-
   if (index_ >= priv->axes->len)
     return FALSE;
 

diff --git a/gdk/gdkdevice.h b/gdk/gdkdevice.h
index d4917f39acabb2d3e096c746ef1af386de00aa91..e40f17f804c5a8fe58ae137b95e7a1c6f95fdc5c 100644 (file)
--- a/gdk/gdkdevice.h
+++ b/gdk/gdkdevice.h
@@ -194,18 +194,6 @@ struct _GdkDevice
 {
   GObject parent_instance;
 
-  /* All fields are read-only */
-  gchar *GSEAL (name);
-  GdkInputSource GSEAL (source);
-  GdkInputMode GSEAL (mode);
-  gboolean GSEAL (has_cursor);      /* TRUE if a X pointer follows device motion */
-
-  gint GSEAL (num_axes);
-  GdkDeviceAxis *GSEAL (axes);
-
-  gint GSEAL (num_keys);
-  GdkDeviceKey *GSEAL (keys);
-
   /*< private >*/
   GdkDevicePrivate *priv;
 };
@@ -224,6 +212,7 @@ GdkInputMode   gdk_device_get_mode      (GdkDevice      *device);
 gboolean       gdk_device_set_mode      (GdkDevice      *device,
                                         GdkInputMode    mode);
 
+gint           gdk_device_get_n_keys    (GdkDevice       *device);
 gboolean       gdk_device_get_key       (GdkDevice       *device,
                                          guint            index_,
                                          guint           *keyval,
@@ -253,7 +242,7 @@ gboolean gdk_device_get_history  (GdkDevice         *device,
 void     gdk_device_free_history (GdkTimeCoord     **events,
                                  gint               n_events);
 
-guint    gdk_device_get_n_axes     (GdkDevice       *device);
+gint     gdk_device_get_n_axes     (GdkDevice       *device);
 GList *  gdk_device_list_axes      (GdkDevice       *device);
 gboolean gdk_device_get_axis_value (GdkDevice       *device,
                                     gdouble         *axes,

diff --git a/gdk/gdkdisplay.c b/gdk/gdkdisplay.c
index 1dab470c5d62f26dbc5e590312bff23e91aa0be1..69d8c6a501b6274bdb69e82498b7305934e21875 100644 (file)
--- a/gdk/gdkdisplay.c
+++ b/gdk/gdkdisplay.c
@@ -494,7 +494,7 @@ gdk_display_pointer_ungrab (GdkDisplay *display,
     {
       device = dev->data;
 
-      if (device->source != GDK_SOURCE_MOUSE)
+      if (gdk_device_get_source (device) != GDK_SOURCE_MOUSE)
         continue;
 
       gdk_device_ungrab (device, time_);
@@ -570,7 +570,7 @@ gdk_display_keyboard_ungrab (GdkDisplay *display,
     {
       device = dev->data;
 
-      if (device->source != GDK_SOURCE_KEYBOARD)
+      if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
         continue;
 
       gdk_device_ungrab (device, time);
@@ -1209,7 +1209,7 @@ generate_grab_broken_event (GdkWindow *window,
       event->grab_broken.implicit = implicit;
       event->grab_broken.grab_window = grab_window;
       gdk_event_set_device (event, device);
-      event->grab_broken.keyboard = (device->source == GDK_SOURCE_KEYBOARD) ? TRUE : FALSE;
+      event->grab_broken.keyboard = (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD) ? TRUE : FALSE;
 
       gdk_event_put (event);
       gdk_event_free (event);
@@ -1538,7 +1538,7 @@ _gdk_display_device_grab_update (GdkDisplay *display,
 
          if (!current_grab->activated)
             {
-              if (device->source != GDK_SOURCE_KEYBOARD)
+              if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
                 switch_to_pointer_grab (display, device, current_grab, NULL, time, current_serial);
             }
 
@@ -1566,7 +1566,7 @@ _gdk_display_device_grab_update (GdkDisplay *display,
       grabs = g_list_delete_link (grabs, grabs);
       g_hash_table_insert (display->device_grabs, device, grabs);
 
-      if (device->source != GDK_SOURCE_KEYBOARD)
+      if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
         switch_to_pointer_grab (display, device,
                                 next_grab, current_grab,
                                 time, current_serial);
@@ -1663,7 +1663,7 @@ _gdk_display_check_grab_ownership (GdkDisplay *display,
 
   g_hash_table_iter_init (&iter, display->device_grabs);
   higher_ownership = device_ownership = GDK_OWNERSHIP_NONE;
-  device_is_keyboard = (device->source == GDK_SOURCE_KEYBOARD);
+  device_is_keyboard = (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD);
 
   while (g_hash_table_iter_next (&iter, &key, &value))
     {
@@ -1679,8 +1679,8 @@ _gdk_display_check_grab_ownership (GdkDisplay *display,
         continue;
 
       /* Discard device if it's not of the same type */
-      if ((device_is_keyboard && dev->source != GDK_SOURCE_KEYBOARD) ||
-          (!device_is_keyboard && dev->source == GDK_SOURCE_KEYBOARD))
+      if ((device_is_keyboard && gdk_device_get_source (dev) != GDK_SOURCE_KEYBOARD) ||
+          (!device_is_keyboard && gdk_device_get_source (dev) == GDK_SOURCE_KEYBOARD))
         continue;
 
       grab = grabs->data;
@@ -1813,7 +1813,7 @@ gdk_display_pointer_is_grabbed (GdkDisplay *display)
     {
       device = dev->data;
 
-      if (device->source == GDK_SOURCE_MOUSE &&
+      if (gdk_device_get_source (device) == GDK_SOURCE_MOUSE &&
           gdk_display_device_is_grabbed (display, device))
         return TRUE;
     }

diff --git a/gdk/gdkevents.c b/gdk/gdkevents.c
index fa61e082b99c9c93c09f71be66a28523d541be00..8b402fc84c5694cd45535ca8f4c9508b9398188e 100644 (file)
--- a/gdk/gdkevents.c
+++ b/gdk/gdkevents.c
@@ -499,17 +499,16 @@ gdk_event_copy (const GdkEvent *event)
     case GDK_BUTTON_PRESS:
     case GDK_BUTTON_RELEASE:
       if (event->button.axes) 
-       new_event->button.axes = g_memdup (event->button.axes, 
-                                            sizeof (gdouble) * event->button.device->num_axes);
+       new_event->button.axes = g_memdup (event->button.axes,
+                                           sizeof (gdouble) * gdk_device_get_n_axes (event->button.device));
       break;
 
     case GDK_MOTION_NOTIFY:
       if (event->motion.axes) 
-       new_event->motion.axes = g_memdup (event->motion.axes, 
-                                          sizeof (gdouble) * event->motion.device->num_axes);
-      
+       new_event->motion.axes = g_memdup (event->motion.axes,
+                                          sizeof (gdouble) * gdk_device_get_n_axes (event->motion.device));
       break;
-      
+
     default:
       break;
     }

diff --git a/gdk/gdkwindow.c b/gdk/gdkwindow.c
index 87d9d55abe2f1ed4cf0f9f54b6d82452cbc9ea9f..62644365d1e6331bb2f8e5b078b638ca84c5a6e5 100644 (file)
--- a/gdk/gdkwindow.c
+++ b/gdk/gdkwindow.c
@@ -8589,7 +8589,7 @@ send_crossing_event (GdkDisplay                 *display,
         }
 
       if (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_MASTER &&
-          device->mode != GDK_MODE_DISABLED &&
+          gdk_device_get_mode (device) != GDK_MODE_DISABLED &&
           !g_list_find (window->devices_inside, device))
         window->devices_inside = g_list_prepend (window->devices_inside, device);
     }
@@ -8955,7 +8955,7 @@ gdk_pointer_grab (GdkWindow *       window,
     {
       device = dev->data;
 
-      if (device->source != GDK_SOURCE_MOUSE)
+      if (gdk_device_get_source (device) != GDK_SOURCE_MOUSE)
         continue;
 
       res = _gdk_windowing_device_grab (device,
@@ -9060,7 +9060,7 @@ gdk_keyboard_grab (GdkWindow *window,
     {
       device = dev->data;
 
-      if (device->source != GDK_SOURCE_KEYBOARD)
+      if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
         continue;
 
       res = _gdk_windowing_device_grab (device,
@@ -9448,7 +9448,7 @@ proxy_pointer_event (GdkDisplay                 *display,
          event->motion.is_hint = is_hint;
          event->motion.device = source_event->motion.device;
           event->motion.axes = g_memdup (source_event->motion.axes,
-                                         sizeof (gdouble) * source_event->motion.device->num_axes);
+                                         sizeof (gdouble) * gdk_device_get_n_axes (source_event->motion.device));
        }
     }
 
@@ -9557,7 +9557,7 @@ proxy_button_event (GdkEvent *source_event,
       event->button.state = state;
       event->button.device = source_event->button.device;
       event->button.axes = g_memdup (source_event->button.axes,
-                                     sizeof (gdouble) * source_event->button.device->num_axes);
+                                     sizeof (gdouble) * gdk_device_get_n_axes (source_event->button.device));
 
       if (type == GDK_BUTTON_PRESS)
        _gdk_event_button_generate (display, event);

diff --git a/gdk/x11/gdkdevice-core.c b/gdk/x11/gdkdevice-core.c
index 1620bde488811d2183ba83758da3ceaa658c1683..a399713b55c4b2066cfc8795ee10f4f15ab1c89f 100644 (file)
--- a/gdk/x11/gdkdevice-core.c
+++ b/gdk/x11/gdkdevice-core.c
@@ -313,7 +313,7 @@ gdk_device_core_grab (GdkDevice    *device,
   else
     xconfine_to = GDK_WINDOW_XID (confine_to);
 
-  if (device->source == GDK_SOURCE_KEYBOARD)
+  if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
     {
       /* Device is a keyboard */
       status = XGrabKeyboard (GDK_DISPLAY_XDISPLAY (display),
@@ -371,7 +371,7 @@ gdk_device_core_ungrab (GdkDevice *device,
 
   display = gdk_device_get_display (device);
 
-  if (device->source == GDK_SOURCE_KEYBOARD)
+  if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
     XUngrabKeyboard (GDK_DISPLAY_XDISPLAY (display), time_);
   else
     XUngrabPointer (GDK_DISPLAY_XDISPLAY (display), time_);

diff --git a/gdk/x11/gdkdevice-xi.c b/gdk/x11/gdkdevice-xi.c
index a1e850ec909574d88a6432a253e930b6e213d5f4..8bebf075d36293c8dc961f010a31cfaea98e976a 100644 (file)
--- a/gdk/x11/gdkdevice-xi.c
+++ b/gdk/x11/gdkdevice-xi.c
@@ -155,7 +155,8 @@ gdk_device_xi_constructed (GObject *object)
                                  device->device_id);
 
   if (gdk_error_trap_pop ())
-    g_warning ("Device %s can't be opened", GDK_DEVICE (device)->name);
+    g_warning ("Device %s can't be opened",
+               gdk_device_get_name (GDK_DEVICE (device)));
 
   if (G_OBJECT_CLASS (gdk_device_xi_parent_class)->constructed)
     G_OBJECT_CLASS (gdk_device_xi_parent_class)->constructed (object);
@@ -556,10 +557,11 @@ gdk_device_xi_update_axes (GdkDevice *device,
   int i;
 
   device_xi = GDK_DEVICE_XI (device);
-  g_return_if_fail (first_axis >= 0 && first_axis + axes_count <= device->num_axes);
+  g_return_if_fail (first_axis >= 0 &&
+                    first_axis + axes_count <= gdk_device_get_n_axes (device));
 
   if (!device_xi->axis_data)
-    device_xi->axis_data = g_new0 (gint, device->num_axes);
+    device_xi->axis_data = g_new0 (gint, gdk_device_get_n_axes (device));
 
   for (i = 0; i < axes_count; i++)
     device_xi->axis_data[first_axis + i] = axis_data[i];
@@ -577,6 +579,7 @@ gdk_device_xi_translate_axes (GdkDevice *device,
   GdkWindow *impl_window;
   gdouble root_x, root_y;
   gdouble temp_x, temp_y;
+  gint n_axes;
   gint i;
 
   device_xi = GDK_DEVICE_XI (device);
@@ -586,7 +589,9 @@ gdk_device_xi_translate_axes (GdkDevice *device,
   if (!gdk_device_xi_get_window_info (impl_window, &root_x, &root_y))
     return;
 
-  for (i = 0; i < device->num_axes; i++)
+  n_axes = gdk_device_get_n_axes (device);
+
+  for (i = 0; i < n_axes; i++)
     {
       GdkAxisUse use;
 
@@ -596,7 +601,7 @@ gdk_device_xi_translate_axes (GdkDevice *device,
         {
         case GDK_AXIS_X:
         case GDK_AXIS_Y:
-          if (device->mode == GDK_MODE_WINDOW)
+          if (gdk_device_get_mode (device) == GDK_MODE_WINDOW)
             _gdk_device_translate_window_coord (device, window,
                                                 i, axis_data[i],
                                                 &axes[i]);

diff --git a/gdk/x11/gdkdevice-xi2.c b/gdk/x11/gdkdevice-xi2.c
index 648923a7436099af8c6ab1f05b73d4037f56589f..41142e2097ef1ef7357f9d94b183aca56c3eedfe 100644 (file)
--- a/gdk/x11/gdkdevice-xi2.c
+++ b/gdk/x11/gdkdevice-xi2.c
@@ -205,7 +205,7 @@ gdk_device_xi2_get_state (GdkDevice       *device,
             case GDK_AXIS_X:
             case GDK_AXIS_Y:
             case GDK_AXIS_IGNORE:
-              if (device->mode == GDK_MODE_WINDOW)
+              if (gdk_device_get_mode (device) == GDK_MODE_WINDOW)
                 _gdk_device_translate_window_coord (device, window, j, value, &axes[j]);
               else
                 {

diff --git a/gdk/x11/gdkdevicemanager-xi.c b/gdk/x11/gdkdevicemanager-xi.c
index 52cea6549765a8e2e94fcbab5ba75580adae17aa..6d65725fad68f1b3d684555fc4d8176c4770346c 100644 (file)
--- a/gdk/x11/gdkdevicemanager-xi.c
+++ b/gdk/x11/gdkdevicemanager-xi.c
@@ -441,7 +441,7 @@ gdk_device_manager_xi_translate_event (GdkEventTranslator *translator,
       event->button.x_root = (gdouble) xdbe->x_root;
       event->button.y_root = (gdouble) xdbe->y_root;
 
-      event->button.axes = g_new0 (gdouble, device->num_axes);
+      event->button.axes = g_new0 (gdouble, gdk_device_get_n_axes (device));
       gdk_device_xi_update_axes (device, xdbe->axes_count,
                                  xdbe->first_axis, xdbe->axis_data);
       gdk_device_xi_translate_axes (device, window,
@@ -487,13 +487,15 @@ gdk_device_manager_xi_translate_event (GdkEventTranslator *translator,
                 xdke->keycode));
 
       if (xdke->keycode < device_xi->min_keycode ||
-         xdke->keycode >= device_xi->min_keycode + device->num_keys)
+         xdke->keycode >= device_xi->min_keycode + gdk_device_get_n_keys (device))
        {
          g_warning ("Invalid device key code received");
          return FALSE;
        }
 
-      event->key.keyval = device->keys[xdke->keycode - device_xi->min_keycode].keyval;
+      gdk_device_get_key (device, xdke->keycode - device_xi->min_keycode,
+                          &event->key.keyval,
+                          &event->key.state);
 
       if (event->key.keyval == 0)
        {
@@ -509,8 +511,7 @@ gdk_device_manager_xi_translate_event (GdkEventTranslator *translator,
       event->key.window = g_object_ref (window);
       event->key.time = xdke->time;
 
-      event->key.state = translate_state (xdke->state, xdke->device_state)
-       | device->keys[xdke->keycode - device_xi->min_keycode].modifiers;
+      event->key.state |= translate_state (xdke->state, xdke->device_state);
 
       /* Add a string translation for the key event */
       if ((event->key.keyval >= 0x20) && (event->key.keyval <= 0xFF))
@@ -552,7 +553,7 @@ gdk_device_manager_xi_translate_event (GdkEventTranslator *translator,
       event->motion.x_root = (gdouble) xdme->x_root;
       event->motion.y_root = (gdouble) xdme->y_root;
 
-      event->motion.axes = g_new0 (gdouble, device->num_axes);
+      event->motion.axes = g_new0 (gdouble, gdk_device_get_n_axes (device));
       gdk_device_xi_update_axes (device, xdme->axes_count,
                                  xdme->first_axis, xdme->axis_data);
       gdk_device_xi_translate_axes (device, window,
@@ -626,7 +627,7 @@ gdk_device_manager_xi_translate_event (GdkEventTranslator *translator,
       for (i = 0; i < xdse->num_classes; i++)
         {
           if (input_class->class == ValuatorClass)
-            gdk_device_xi_update_axes (device, device->num_axes, 0,
+            gdk_device_xi_update_axes (device, gdk_device_get_n_axes (device), 0,
                                        ((XValuatorState *)input_class)->valuators);
 
           input_class = (XInputClass *)(((char *)input_class)+input_class->length);

diff --git a/gdk/x11/gdkdevicemanager-xi2.c b/gdk/x11/gdkdevicemanager-xi2.c
index fd4207419d299cbf4f1e6832017d87278093fb84..f97717d522a8cc561030e5677970cc9afde7ed89 100644 (file)
--- a/gdk/x11/gdkdevicemanager-xi2.c
+++ b/gdk/x11/gdkdevicemanager-xi2.c
@@ -268,7 +268,7 @@ add_device (GdkDeviceManagerXI2 *device_manager,
   else if (dev->use == XIFloatingSlave)
     device_manager->floating_devices = g_list_append (device_manager->floating_devices, device);
   else
-    g_warning ("Unhandled device: %s\n", device->name);
+    g_warning ("Unhandled device: %s\n", gdk_device_get_name (device));
 
   if (emit_signal)
     g_signal_emit_by_name (device_manager, "device-added", device);
@@ -755,7 +755,7 @@ translate_axes (GdkDevice       *device,
         {
         case GDK_AXIS_X:
         case GDK_AXIS_Y:
-          if (device->mode == GDK_MODE_WINDOW)
+          if (gdk_device_get_mode (device) == GDK_MODE_WINDOW)
             _gdk_device_translate_window_coord (device, window, i, val, &axes[i]);
           else
             {
@@ -1010,7 +1010,7 @@ gdk_device_manager_xi2_translate_event (GdkEventTranslator *translator,
                                                  event->button.window,
                                                  &xev->valuators);
 
-            if (event->button.device->mode == GDK_MODE_WINDOW)
+            if (gdk_device_get_mode (event->button.device) == GDK_MODE_WINDOW)
               {
                 GdkDevice *device = event->button.device;
 
@@ -1061,7 +1061,7 @@ gdk_device_manager_xi2_translate_event (GdkEventTranslator *translator,
                                              event->motion.window,
                                              &xev->valuators);
 
-        if (event->motion.device->mode == GDK_MODE_WINDOW)
+        if (gdk_device_get_mode (event->motion.device) == GDK_MODE_WINDOW)
           {
             GdkDevice *device = event->motion.device;
 

diff --git a/gdk/x11/gdkdisplay-x11.c b/gdk/x11/gdkdisplay-x11.c
index 2bdfd454020194dc5c4f402a9fe3312eedd4d737..148d167d4397412bcf2ee9fe0051ee55c8c20df1 100644 (file)
--- a/gdk/x11/gdkdisplay-x11.c
+++ b/gdk/x11/gdkdisplay-x11.c
@@ -1152,7 +1152,7 @@ _gdk_input_init (GdkDisplay *display)
     {
       device = l->data;
 
-      if (device->source == GDK_SOURCE_KEYBOARD)
+      if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
         continue;
 
       display_x11->input_devices = g_list_prepend (display_x11->input_devices,
@@ -1170,7 +1170,7 @@ _gdk_input_init (GdkDisplay *display)
     {
       device = list->data;
 
-      if (device->source != GDK_SOURCE_MOUSE)
+      if (gdk_device_get_source (device) != GDK_SOURCE_MOUSE)
         continue;
 
       display->core_pointer = device;

diff --git a/gtk/gtkbutton.c b/gtk/gtkbutton.c
index 8fd97ad2e58a77ec4dc5bbaf4e1bb62bfde8233b..71fb865f437f11c3dff75b2c7bc0df9a789a588f 100644 (file)
--- a/gtk/gtkbutton.c
+++ b/gtk/gtkbutton.c
@@ -1827,10 +1827,10 @@ gtk_real_button_activate (GtkButton *button)
 
   device = gtk_get_current_event_device ();
 
-  if (device && device->source != GDK_SOURCE_KEYBOARD)
+  if (device && gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
     device = gdk_device_get_associated_device (device);
 
-  g_return_if_fail (device && device->source == GDK_SOURCE_KEYBOARD);
+  g_return_if_fail (device && gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD);
 
   if (gtk_widget_get_realized (widget) && !priv->activate_timeout)
     {

diff --git a/gtk/gtkcellrendereraccel.c b/gtk/gtkcellrendereraccel.c
index f18ce56d5169ff9a181f02395e0dd9bf2bec439f..b0a42dbc36446b6fd9a30823444452c2474fa969 100644 (file)
--- a/gtk/gtkcellrendereraccel.c
+++ b/gtk/gtkcellrendereraccel.c
@@ -616,7 +616,7 @@ gtk_cell_renderer_accel_start_editing (GtkCellRenderer      *cell,
   if (!device)
     return NULL;
 
-  if (device->source == GDK_SOURCE_KEYBOARD)
+  if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
     {
       keyb = device;
       pointer = gdk_device_get_associated_device (device);

diff --git a/gtk/gtkcolorsel.c b/gtk/gtkcolorsel.c
index c294266d329d90f18308e3a970fb87d0f9fe860a..2ed64827afdb56e700031a097a73fcba8c7bfc14 100644 (file)
--- a/gtk/gtkcolorsel.c
+++ b/gtk/gtkcolorsel.c
@@ -1912,7 +1912,7 @@ get_screen_color (GtkWidget *button)
 
   device = gtk_get_current_event_device ();
 
-  if (device->source == GDK_SOURCE_KEYBOARD)
+  if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
     {
       keyb_device = device;
       pointer_device = gdk_device_get_associated_device (device);

diff --git a/gtk/gtkcombobox.c b/gtk/gtkcombobox.c
index 9df273d81c3a77e003d554c82f901002d4441a55..0a922fa0235ee6e46501bb351bf606d711942a9e 100644 (file)
--- a/gtk/gtkcombobox.c
+++ b/gtk/gtkcombobox.c
@@ -2199,7 +2199,7 @@ gtk_combo_box_popup_for_device (GtkComboBox *combo_box,
 
   time = gtk_get_current_event_time ();
 
-  if (device->source == GDK_SOURCE_KEYBOARD)
+  if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
     {
       keyboard = device;
       pointer = gdk_device_get_associated_device (device);

diff --git a/gtk/gtkdnd.c b/gtk/gtkdnd.c
index d95118163224e5e4e606d4be91785ea9bbf67988..08496d5761dfd69687fff5dbf1f688b026de046d 100644 (file)
--- a/gtk/gtkdnd.c
+++ b/gtk/gtkdnd.c
@@ -2329,7 +2329,7 @@ gtk_drag_begin_internal (GtkWidget         *widget,
 
       pointer = gdk_event_get_device (event);
 
-      if (pointer->source == GDK_SOURCE_KEYBOARD)
+      if (gdk_device_get_source (pointer) == GDK_SOURCE_KEYBOARD)
         {
           keyboard = pointer;
           pointer = gdk_device_get_associated_device (keyboard);

diff --git a/gtk/gtkentry.c b/gtk/gtkentry.c
index 3c0d4b4ff15989f2d0f8db878b99318465457c85..cd70918e1eba4b952dc8de2377d8e3f794fec047 100644 (file)
--- a/gtk/gtkentry.c
+++ b/gtk/gtkentry.c
@@ -9710,7 +9710,7 @@ gtk_entry_completion_changed (GtkWidget *widget,
 
   device = gtk_get_current_event_device ();
 
-  if (device && device->source == GDK_SOURCE_KEYBOARD)
+  if (device && gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
     device = gdk_device_get_associated_device (device);
 
   if (device)

diff --git a/gtk/gtkmenu.c b/gtk/gtkmenu.c
index 743ad5a63d52afe8bed812748b216e03e9cc8581..3032f3b95e8ded4624d8e13eafa4dde8e26d7f86 100644 (file)
--- a/gtk/gtkmenu.c
+++ b/gtk/gtkmenu.c
@@ -1469,7 +1469,7 @@ gtk_menu_popup_for_device (GtkMenu             *menu,
   menu_shell = GTK_MENU_SHELL (menu);
   priv = gtk_menu_get_private (menu);
 
-  if (device->source == GDK_SOURCE_KEYBOARD)
+  if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
     {
       keyboard = device;
       pointer = gdk_device_get_associated_device (device);

diff --git a/gtk/gtkmenushell.c b/gtk/gtkmenushell.c
index e531de1c13d90c99f58bfd0cafc7e3686f60c589..d630cdd253502075b4aacfec3059a78d627a24fd 100644 (file)
--- a/gtk/gtkmenushell.c
+++ b/gtk/gtkmenushell.c
@@ -1807,7 +1807,7 @@ _gtk_menu_shell_set_grab_device (GtkMenuShell *menu_shell,
 
   if (!device)
     priv->grab_pointer = NULL;
-  else if (device->source == GDK_SOURCE_KEYBOARD)
+  else if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
     priv->grab_pointer = gdk_device_get_associated_device (device);
   else
     priv->grab_pointer = device;

diff --git a/gtk/gtkplug-x11.c b/gtk/gtkplug-x11.c
index ca7e3e085724c56e8a62d404ef32e2bf222c8913..ca3af73c270ba02a8683ea5dc3f2dd89c1d9f296 100644 (file)
--- a/gtk/gtkplug-x11.c
+++ b/gtk/gtkplug-x11.c
@@ -378,7 +378,7 @@ _gtk_plug_windowing_filter_func (GdkXEvent *gdk_xevent,
           {
             GdkDevice *device = d->data;
 
-            if (device->source == GDK_SOURCE_KEYBOARD)
+            if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
               keyboard = device;
           }
 

diff --git a/gtk/gtkscalebutton.c b/gtk/gtkscalebutton.c
index fb2624e53edb94fc771a4db07d3d5e5ec720e975..f3894ff84b698fbfc0488b3a560ccb51f80c9445 100644 (file)
--- a/gtk/gtkscalebutton.c
+++ b/gtk/gtkscalebutton.c
@@ -1027,7 +1027,7 @@ gtk_scale_popup (GtkWidget *widget,
 
   device = gdk_event_get_device (event);
 
-  if (device->source == GDK_SOURCE_KEYBOARD)
+  if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
     {
       keyboard = device;
       pointer = gdk_device_get_associated_device (device);

diff --git a/gtk/gtktooltip.c b/gtk/gtktooltip.c
index 309013f8470464f1d9312c72bccf26c230713f51..16018b609d8730e43241b10e078bedef7e367928 100644 (file)
--- a/gtk/gtktooltip.c
+++ b/gtk/gtktooltip.c
@@ -1350,7 +1350,7 @@ _gtk_tooltip_focus_in (GtkWidget *widget)
 
   device = gtk_get_current_event_device ();
 
-  if (device && device->source == GDK_SOURCE_KEYBOARD)
+  if (device && gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
     device = gdk_device_get_associated_device (device);
 
   /* This function should be called by either a focus in event,

diff --git a/gtk/gtktreeview.c b/gtk/gtktreeview.c
index 66e8a5f5d2f35e5b464b901caeb8a95e260618a1..85280038a8d0cb9e8e30ac7c6ded9f5ed07ad6af 100644 (file)
--- a/gtk/gtktreeview.c
+++ b/gtk/gtktreeview.c
@@ -10407,7 +10407,7 @@ send_focus_change (GtkWidget *widget,
       GdkEvent *fevent;
       GdkWindow *window;
 
-      if (dev->source != GDK_SOURCE_KEYBOARD)
+      if (gdk_device_get_source (dev) != GDK_SOURCE_KEYBOARD)
         continue;
 
       window = gtk_widget_get_window (widget);

diff --git a/gtk/gtkwindow.c b/gtk/gtkwindow.c
index 0621701be9a619385bd299f6699c3d8bd7a73179..1f7134e646852351ceacdf416c788a059c2bec84 100644 (file)
--- a/gtk/gtkwindow.c
+++ b/gtk/gtkwindow.c
@@ -5923,7 +5923,7 @@ do_focus_change (GtkWidget *widget,
       GdkDevice *dev = d->data;
       GdkEvent *fevent;
 
-      if (dev->source != GDK_SOURCE_KEYBOARD)
+      if (gdk_device_get_source (dev) != GDK_SOURCE_KEYBOARD)
         continue;
 
       /* Skip non-master keyboards that haven't

diff --git a/tests/testinput.c b/tests/testinput.c
index ad7b7e24156c869787d271005f2e42190e038178..b125c7562c8551e019d363aca34909f22b8bc6de 100644 (file)
--- a/tests/testinput.c
+++ b/tests/testinput.c
@@ -46,7 +46,7 @@ static void
 update_cursor (GtkWidget *widget,  gdouble x, gdouble y)
 {
   static gint cursor_present = 0;
-  gint state = !current_device->has_cursor && cursor_proximity;
+  gint state = !gdk_device_get_has_cursor (current_device) && cursor_proximity;
 
   if (surface != NULL)
     {
@@ -167,9 +167,9 @@ print_axes (GdkDevice *device, gdouble *axes)
   
   if (axes)
     {
-      g_print ("%s ", device->name);
-      
-      for (i=0; i<device->num_axes; i++)
+      g_print ("%s ", gdk_device_get_name (device));
+
+      for (i = 0; i < gdk_device_get_n_axes (device); i++)
        g_print ("%g ", axes[i]);
 
       g_print ("\n");
@@ -188,8 +188,9 @@ button_press_event (GtkWidget *widget, GdkEventButton *event)
 
       print_axes (event->device, event->axes);
       gdk_event_get_axis ((GdkEvent *)event, GDK_AXIS_PRESSURE, &pressure);
-      draw_brush (widget, event->device->source, event->x, event->y, pressure);
-      
+      draw_brush (widget, gdk_device_get_source (event->device),
+                  event->x, event->y, pressure);
+
       motion_time = event->time;
     }
 
@@ -232,7 +233,8 @@ motion_notify_event (GtkWidget *widget, GdkEventMotion *event)
              gdk_device_get_axis (event->device, events[i]->axes, GDK_AXIS_X, &x);
              gdk_device_get_axis (event->device, events[i]->axes, GDK_AXIS_Y, &y);
              gdk_device_get_axis (event->device, events[i]->axes, GDK_AXIS_PRESSURE, &pressure);
-             draw_brush (widget,  event->device->source, x, y, pressure);
+             draw_brush (widget, gdk_device_get_source (event->device),
+                          x, y, pressure);
 
              print_axes (event->device, events[i]->axes);
            }
@@ -244,7 +246,8 @@ motion_notify_event (GtkWidget *widget, GdkEventMotion *event)
 
          gdk_event_get_axis ((GdkEvent *)event, GDK_AXIS_PRESSURE, &pressure);
 
-         draw_brush (widget,  event->device->source, event->x, event->y, pressure);
+         draw_brush (widget, gdk_device_get_source (event->device),
+                      event->x, event->y, pressure);
        }
       motion_time = event->time;
     }